import 'package:playtruly/common/services/http.dart';
import 'package:playtruly/common/models/comment_models.dart';
import 'package:playtruly/common/utils/encryption_util.dart';
import 'dart:developer' as developer;
import 'dart:convert';

/// 评论相关API
class CommentApi {

  /// 删除评论（使用AES加密，按照MyApplication2格式）
  /// [commentId] 评论ID（必填，传入int类型但会转为String）
  /// 返回删除结果
  /// 注：使用编辑接口实现软删除，与MyApplication2一致
  static Future<Map<String, dynamic>> deleteComment({
    required int commentId,
  }) async {
    try {
      developer.log('🔄 =============== 开始删除评论（AES加密） ===============');
      developer.log('🎯 评论ID: $commentId');
      
      // 创建请求参数 - 按照MyApplication2格式
      final requestData = <String, dynamic>{
        'comment_id': commentId.toString(),  // String类型，与MyApplication2一致
        'status': ['删除'],                    // JSON数组，关键删除标识
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000,  // long类型，与MyApplication2一致
      };
      
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密评论删除数据...');
      // 使用手动加密，不自动添加timestamp（已手动添加）
      final encryptedData = EncryptionUtil.aesEncrypt(jsonEncode(requestData));
      final encryptedPayload = {'encrypted_data': encryptedData};
      
      developer.log('🚀 准备发送加密请求到: /comments/edit (使用编辑接口实现删除)');
      
      // 发送请求到编辑接口，修正地址（去掉末尾斜杠）
      final response = await HttpService.to.post(
        '/comments/edit',
        data: encryptedPayload,
      );

      developer.log('✅ 删除评论响应: $response');
      
      if (response['status'] == 'success') {
        developer.log('🎉 评论删除成功！');
      } else {
        developer.log('❌ 评论删除失败: ${response['message']}');
      }
      
      return response;
    } catch (e) {
      developer.log('💥 删除评论API异常: $e');
      return {
        'status': 'error',
        'message': '删除评论失败: ${e.toString()}',
      };
    }
  }
  
  /// 查询附近评论列表（使用AES加密）
  /// [latitude] 纬度（必填）
  /// [longitude] 经度（必填）
  /// [radius] 搜索半径（公里），默认50
  /// [limit] 返回数量限制，默认50
  /// [page] 页码，用于分页（新增）
  /// 返回CommentListResponse对象
  static Future<CommentListResponse> getNearbyComments({
    required double latitude,
    required double longitude,
    double? radius,
    int? limit,
    int? page, // 新增分页参数
  }) async {
    try {
      developer.log('🔄 =============== 开始查询附近评论（AES加密） ===============');
      developer.log('📍 位置: $latitude, $longitude');
      
      // 创建请求参数
      final requestData = <String, dynamic>{
        'latitude': latitude,
        'longitude': longitude,
        'radius': radius ?? 50.0,
        'limit': limit ?? 50,
      };
      
      // 如果提供了分页参数，添加到请求中
      if (page != null) {
        requestData['page'] = page;
      }
      
      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密评论查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /comments/nearby/');
      
      // 发送请求
      final response = await HttpService.to.post(
        '/comments/nearby/',
        data: encryptedPayload,
      );

      developer.log('📨 评论查询响应: $response');

      // 解析响应
      final commentResponse = CommentListResponse.fromJson(response);
      
      if (commentResponse.isSuccess) {
        developer.log('✅ 评论列表查询成功: 共${commentResponse.commentCount}个评论');
        developer.log('分页信息: ${commentResponse.pagination?.toString() ?? "无分页"}');
      } else {
        developer.log('❌ 评论列表查询失败: ${commentResponse.errorMessage}');
      }

      return commentResponse;
    } catch (e) {
      developer.log('💥 查询评论列表异常: $e');
      // 如果出现异常，返回失败响应
      return CommentListResponse(
        status: 'error',
        message: '查询评论列表失败: ${e.toString()}',
        data: [],
      );
    }
  }

  /// 根据当前位置查询评论列表（简化版本）
  /// 使用默认的经纬度
  static Future<CommentListResponse> getCommentsAtCurrentLocation({
    double? radius,
    int? limit,
  }) async {
    // 使用默认的经纬度（北京）
    const double defaultLatitude = 39.915;
    const double defaultLongitude = 116.404;

    return await getNearbyComments(
      latitude: defaultLatitude,
      longitude: defaultLongitude,
      radius: radius,
      limit: limit,
    );
  }

  /// 发布新评论
  /// [commentTitle] 评论标题（必填）
  /// [commentContent] 评论内容（必填）
  /// [commentCategory] 评论分类（必填）
  /// [publisherId] 发布者ID（必填）
  /// [publisherNickname] 发布者昵称（必填）
  /// [longitude] 经度（必填）
  /// [latitude] 纬度（必填）
  /// 其他参数为可选


  /// 点赞评论（使用AES加密）
  /// 🔥 根据MyApplication2实际使用的字段名称修正
  /// [userId] 用户ID（必填）
  /// [commentId] 评论ID（必填）
  static Future<Map<String, dynamic>> likeComment({
    required int userId,
    required int commentId,
  }) async {
    try {
      developer.log('🔄 =============== 开始评论点赞（AES加密） ===============');
      developer.log('👤 用户ID: $userId');
      developer.log('📝 评论ID: $commentId');
      
      // 🔥 使用MyApplication2的字段格式
      final requestData = {
        'userId': userId,
        'commentId': commentId,
        'type': 1,  // MyApplication2固定传1
      };

      developer.log('📊 请求参数（加密前）: $requestData');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密点赞数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      developer.log('🚀 准备发送加密请求到: /comments/like');

      // 发送请求
      final response = await HttpService.to.post(
        '/comments/like',
        data: encryptedPayload,
      );

      developer.log('📨 评论点赞响应: $response');
      return response;
    } catch (e) {
      developer.log('💥 评论点赞异常: $e');
      return {
        'status': 'error',
        'message': '评论点赞失败: ${e.toString()}',
      };
    }
  }



  /// 查询评论详情（使用MyApplication2的query/activity_user接口，AES加密）
  /// [commentId] 评论ID（必填）
  /// [userId] 用户ID（可选，用于检查点赞状态等）
  static Future<Map<String, dynamic>> getCommentDetail({
    required int commentId,
    int? userId,
  }) async {
    try {
      developer.log('');
      developer.log('🔍 =============== 开始查询评论详情（AES加密） ===============');
      developer.log('📝 评论ID: $commentId');
      if (userId != null) developer.log('👤 用户ID: $userId');
      
      // 准备原始请求数据（按照MyApplication2的格式）
      final originalData = <String, dynamic>{
        'commentId': commentId,
      };
      
      // 添加用户ID（如果提供）
      if (userId != null) {
        originalData['userId'] = userId.toString();
      }
      
      developer.log('📊 原始请求数据: ${jsonEncode(originalData)}');
      
      // 创建加密载荷
      Map<String, dynamic> encryptedPayload;
      try {
        encryptedPayload = EncryptionUtil.createEncryptedPayload(originalData);
      } catch (e) {
        developer.log('❌ 创建加密载荷失败: $e');
        throw Exception('加密数据失败: $e');
      }
      
      developer.log('🚀 准备发送加密请求到: /query/activity_user/（修正URL斜杠）');
      developer.log('📦 请求载荷: ${jsonEncode(encryptedPayload)}');
      developer.log('🔒 加密数据长度: ${encryptedPayload['encrypted_data']?.length ?? 0} 字符');
      
      // 发送加密请求
      final startTime = DateTime.now();
      developer.log('⏰ 请求开始时间: ${startTime.toIso8601String()}');
      
      final response = await HttpService.to.post(
        '/query/activity_user/',  // 🔥 修复：添加末尾斜杠避免307重定向
        data: encryptedPayload,
      );

      final endTime = DateTime.now();
      final duration = endTime.difference(startTime).inMilliseconds;
      developer.log('⏰ 请求结束时间: ${endTime.toIso8601String()}');
      developer.log('⏱️ 请求耗时: ${duration}ms');
      
      developer.log('📨 服务器响应: ${jsonEncode(response)}');
      
      // 检查响应状态
      final status = response['status'] ?? 'unknown';
      if (status == 'success') {
        developer.log('✅ 评论详情查询成功！');
      } else if (status == 'error') {
        final errorMsg = response['message'] ?? '未知错误';
        developer.log('❌ 服务器返回错误: $errorMsg');
      } else {
        developer.log('⚠️ 未知响应状态: $status');
      }
      
      developer.log('🏁 =============== 评论详情查询完成 ===============');
      developer.log('');
      
      return response;
    } catch (e, stackTrace) {
      developer.log('');
      developer.log('💥 =============== 查询评论详情异常 ===============');
      developer.log('❌ 异常信息: $e');
      developer.log('📍 堆栈跟踪: $stackTrace');
      developer.log('🏁 =============== 异常处理结束 ===============');
      developer.log('');
      
      return {
        'status': 'error',
        'message': '查询评论详情失败: ${e.toString()}',
        'error_type': 'client_exception',
      };
    }
  }

  /// 查询评论详情（明文方式，用于对比测试）
  /// [commentId] 评论ID（必填）
  static Future<Map<String, dynamic>> getCommentDetailPlaintext({
    required int commentId,
  }) async {
    try {
      developer.log('');
      developer.log('📝 =============== 开始明文方式查询评论详情 ===============');
      developer.log('📝 评论ID: $commentId');
      
      // 准备明文请求数据（按照测试结果，timestamp应该是数字类型）
      final timestamp = DateTime.now().millisecondsSinceEpoch ~/ 1000;
      final requestData = {
        'commentId': commentId,
        'timestamp': timestamp,
      };
      
      developer.log('📊 明文请求数据: ${jsonEncode(requestData)}');
      developer.log('🚀 准备发送明文请求到: /query/activity_user/（使用统一接口）');
      
      // 发送明文请求
      final startTime = DateTime.now();
      developer.log('⏰ 明文请求开始时间: ${startTime.toIso8601String()}');
      
      final response = await HttpService.to.post(
        '/query/activity_user/',  // 🔥 修正：使用和加密版本一致的接口
        data: requestData,
      );

      final endTime = DateTime.now();
      final duration = endTime.difference(startTime).inMilliseconds;
      developer.log('⏰ 明文请求结束时间: ${endTime.toIso8601String()}');
      developer.log('⏱️ 明文请求耗时: ${duration}ms');
      
      developer.log('📨 明文服务器响应: ${jsonEncode(response)}');
      
      // 检查响应状态
      final status = response['status'] ?? 'unknown';
      if (status == 'success') {
        developer.log('✅ 明文评论详情查询成功！');
      } else if (status == 'error') {
        final errorMsg = response['message'] ?? '未知错误';
        developer.log('❌ 明文服务器返回错误: $errorMsg');
      } else {
        developer.log('⚠️ 明文未知响应状态: $status');
      }
      
      developer.log('🏁 =============== 明文评论详情查询完成 ===============');
      developer.log('');
      
      return response;
    } catch (e, stackTrace) {
      developer.log('');
      developer.log('💥 =============== 明文查询评论详情异常 ===============');
      developer.log('❌ 明文异常信息: $e');
      developer.log('📍 明文堆栈跟踪: $stackTrace');
      developer.log('🏁 =============== 明文异常处理结束 ===============');
      developer.log('');
      
      return {
        'status': 'error',
        'message': '明文查询评论详情失败: ${e.toString()}',
        'error_type': 'client_exception',
      };
    }
  }

  /// 生成curl测试命令（调试用）
  /// [commentId] 评论ID
  static void generateCurlCommand(int commentId) {
    try {
      developer.log('');
      developer.log('🧪 =============== 生成curl测试命令 ===============');
      
      // 1. 生成加密版本的curl命令
      developer.log('🔐 --- 加密版本curl命令 ---');
      final originalData = {
        'commentId': commentId,
      };
      
      developer.log('📊 原始数据: ${jsonEncode(originalData)}');
      
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(originalData);
      final encryptedDataStr = encryptedPayload['encrypted_data'];
      
      final encryptedCurlCommand = '''
curl -X POST "http://124.71.77.44:2233/comments/detail/" \\
  -H "Content-Type: application/json" \\
  -d '{
    "encrypted_data": "$encryptedDataStr"
  }'
''';

      developer.log('📋 加密curl命令:');
      developer.log(encryptedCurlCommand);
      
      // 2. 生成明文版本的curl命令
      developer.log('📝 --- 明文版本curl命令（对比用） ---');
      final timestamp = DateTime.now().millisecondsSinceEpoch ~/ 1000;
      final plaintextData = {
        'commentId': commentId,
        'timestamp': timestamp,
      };
      
      final plaintextCurlCommand = '''
curl -X POST "http://124.71.77.44:2233/comments/detail/" \\
  -H "Content-Type: application/json" \\
  -d '${jsonEncode(plaintextData)}'
''';

      developer.log('📋 明文curl命令:');
      developer.log(plaintextCurlCommand);
      
      developer.log('🔍 curl命令验证:');
      developer.log('  - 评论ID: $commentId (${commentId.runtimeType})');
      developer.log('  - 加密数据长度: ${encryptedDataStr?.length ?? 0} 字符');
      developer.log('  - 明文数据: ${jsonEncode(plaintextData)}');
      
      developer.log('🏁 =============== curl命令生成完成 ===============');
      developer.log('');
      
    } catch (e, stackTrace) {
      developer.log('❌ 生成curl命令失败: $e');
      developer.log('📍 错误堆栈: $stackTrace');
    }
  }

  /// 编辑评论
  /// [commentId] 评论ID（必填）
  static Future<Map<String, dynamic>> editComment({
    required int commentId,
    String? commentTitle,
    String? commentContent,
    List<String>? commentImages,
    List<String>? commentCategory,
    List<String>? commentTags,
    String? commentLocation,
    List<String>? shoppingImages,
    double? longitude,
    double? latitude,
    Map<String, dynamic>? extraData,
  }) async {
    try {
      // 生成时间戳（long类型，与MyApplication2一致）
      final timestamp = DateTime.now().millisecondsSinceEpoch ~/ 1000;
      
      final requestData = <String, dynamic>{
        'comment_id': commentId,
        'timestamp': timestamp,
      };

      // 只添加非空的字段
      if (commentTitle != null) requestData['commentTitle'] = commentTitle;
      if (commentContent != null) requestData['commentContent'] = commentContent;
      if (commentImages != null) requestData['commentImages'] = commentImages;
      if (commentCategory != null) requestData['commentCategory'] = commentCategory;
      if (commentTags != null) requestData['commentTags'] = commentTags;
      if (commentLocation != null) requestData['commentLocation'] = commentLocation;
      if (shoppingImages != null) requestData['shoppingImages'] = shoppingImages;
      if (longitude != null) requestData['longitude'] = longitude;
      if (latitude != null) requestData['latitude'] = latitude;
      if (extraData != null) requestData['extraData'] = extraData;

      developer.log('编辑评论请求参数: $requestData');

      // 发送请求
      final response = await HttpService.to.put(
        '/comments/$commentId',
        data: requestData,
      );

      developer.log('✅ 评论编辑成功: $response');
      return response;
    } catch (e) {
      developer.log('💥 编辑评论异常: $e');
      return {
        'status': 'error',
        'message': '编辑评论失败: ${e.toString()}',
      };
    }
  }

  /// 查询店铺评论
  /// [storeName] 店铺名称（必填）
  static Future<Map<String, dynamic>> getStoreComments({
    required String storeName,
  }) async {
    try {
      // 生成时间戳（long类型，与MyApplication2一致）
      final timestamp = DateTime.now().millisecondsSinceEpoch ~/ 1000;
      
      final requestData = {
        'store_name': storeName,
        'timestamp': timestamp,
      };

      developer.log('查询店铺评论请求参数: $requestData');

      // 发送请求
      final response = await HttpService.to.post(
        '/query/comments_by_store/',
        data: requestData,
      );

      developer.log('✅ 店铺评论查询成功: $response');
      return response;
    } catch (e) {
      developer.log('💥 查询店铺评论异常: $e');
      return {
        'status': 'error',
        'message': '查询店铺评论失败: ${e.toString()}',
      };
    }
  }

  /// 发布新评论（使用AES加密，按照MyApplication2格式）
  /// 根据MyApplication2的接口格式实现
  static Future<Map<String, dynamic>> publishComment({
    required String commentTitle,
    required String commentContent,
    required List<String> commentCategory,
    required String publisherId,  // 改为String类型，与MyApplication2一致
    required String publisherNickname,
    required double longitude,
    required double latitude,
    List<String>? commentImages,
    List<String>? commentTags,
    String? commentLocation,
    List<String>? shoppingImages,
    String? publisherAvatar,  // 字段名改为publisherAvatar
    String? publisherSignature,
    // 移除MyApplication2没有的字段
    // List<String>? publisherTags,
    // int? publisherPoints,
    // List<String>? status,
    required List<Map<String, dynamic>> extraData,  // 改为数组格式
  }) async {
    try {
      developer.log('🔄 =============== 开始发布评论（AES加密） ===============');
      developer.log('🎯 标题: $commentTitle');
      developer.log('📖 内容: ${commentContent.substring(0, commentContent.length > 50 ? 50 : commentContent.length)}...');
      developer.log('👤 发布者ID: $publisherId');
      
      // 准备请求数据 - 按照MyApplication2的格式
      final data = {
        'commentTitle': commentTitle,
        'commentContent': commentContent,
        'commentCategory': commentCategory,
        'publisherId': publisherId,  // String类型
        'publisherNickname': publisherNickname,
        'longitude': longitude,
        'latitude': latitude,
        'extraData': extraData,  // 数组格式
        'timestamp': DateTime.now().millisecondsSinceEpoch ~/ 1000, // 手动添加timestamp（long类型），与MyApplication2一致
      };
      
      // 添加可选参数
      if (commentImages != null && commentImages.isNotEmpty) {
        data['commentImages'] = commentImages;
      }
      if (commentTags != null && commentTags.isNotEmpty) {
        data['commentTags'] = commentTags;
      }
      if (commentLocation != null && commentLocation.isNotEmpty) {
        data['commentLocation'] = commentLocation;
      }
      if (shoppingImages != null && shoppingImages.isNotEmpty) {
        data['shoppingImages'] = shoppingImages;
      }
      if (publisherAvatar != null && publisherAvatar.isNotEmpty) {
        data['publisherAvatar'] = publisherAvatar;  // 字段名改为publisherAvatar
      }
      if (publisherSignature != null && publisherSignature.isNotEmpty) {
        data['publisherSignature'] = publisherSignature;
      }
      
      developer.log('📊 请求参数（加密前）: ${jsonEncode(data)}');
      
      // 🔥 使用AES加密（不再自动添加timestamp）
      developer.log('🔐 开始AES加密评论发布数据...');
      final encryptedData = EncryptionUtil.aesEncrypt(jsonEncode(data));
      final encryptedPayload = {'encrypted_data': encryptedData};
      
      developer.log('🚀 准备发送加密请求到: /comments/');
      
      final startTime = DateTime.now();
      developer.log('⏰ 发布开始时间: ${startTime.toIso8601String()}');
      
      final response = await HttpService.to.post('/comments/', data: encryptedPayload);
      
      final endTime = DateTime.now();
      final duration = endTime.difference(startTime).inMilliseconds;
      developer.log('⏰ 发布结束时间: ${endTime.toIso8601String()}');
      developer.log('⏱️ 发布耗时: ${duration}ms');
      developer.log('📨 服务器响应: ${jsonEncode(response)}');
      
      final responseStatus = response['status'] ?? 'unknown';
      if (responseStatus == 'success') {
        final commentId = response['comment_id'];
        final pointsChange = response['pointsChange'] ?? 0;
        developer.log('✅ 评论发布成功！');
        developer.log('🆔 新评论ID: $commentId');
        developer.log('💰 积分变化: +$pointsChange');
      } else if (responseStatus == 'error') {
        final errorMsg = response['message'] ?? '未知错误';
        developer.log('❌ 评论发布失败: $errorMsg');
      }
      
      developer.log('🏁 =============== 评论发布完成 ===============');
      
      return response;
    } catch (e, stackTrace) {
      developer.log('💥 =============== 评论发布异常 ===============');
      developer.log('❌ 异常信息: $e');
      developer.log('📍 堆栈跟踪: $stackTrace');
      developer.log('🏁 =============== 异常处理结束 ===============');
      
      return {
        'status': 'error',
        'message': '发布评论失败: ${e.toString()}',
        'error_type': 'client_exception',
      };
    }
  }

  /// 添加评论回复（使用AES加密）
  /// 🔥 根据MyApplication2实际使用的字段名称修正
  static Future<Map<String, dynamic>> addCommentReply({
    required int commentId,
    required int userId,
    required String userNickname,
    required String replyContent,
    String? userAvatarUrl,
    String? userSignature,
    List<String>? userTags,
    int? userPoints,
    Map<String, dynamic>? extraData,
  }) async {
    try {
      
      // 🔥 准备请求数据（使用MyApplication2的字段名称）
      final data = {
        'comment_id': commentId,  // MyApplication2使用 comment_id
        'publisherId': userId,    // MyApplication2使用 publisherId
        'publisherNickname': userNickname,  // MyApplication2使用 publisherNickname
        'replyContent': replyContent,
      };
      
      // 🔥 添加可选参数（使用MyApplication2的字段名称）
      if (userAvatarUrl != null && userAvatarUrl.isNotEmpty) {
        data['publisherAvatar'] = userAvatarUrl;  // MyApplication2使用 publisherAvatar
      }
      if (userSignature != null && userSignature.isNotEmpty) {
        data['publisherSignature'] = userSignature;  // MyApplication2使用 publisherSignature
      }
      if (userTags != null && userTags.isNotEmpty) {
        data['publisherTags'] = userTags;  // MyApplication2使用 publisherTags
      }
      if (userPoints != null) {
        data['publisherPoints'] = userPoints;  // MyApplication2使用 publisherPoints
      }
      if (extraData != null && extraData.isNotEmpty) {
        data['extraData'] = extraData;
      }
      
      developer.log('📊 请求参数（加密前）: ${jsonEncode(data)}');
      developer.log('🔍 字段对比验证:');
      developer.log('   ✅ comment_id: $commentId (MyApplication2格式)');
      developer.log('   ✅ publisherId: $userId (MyApplication2格式)');
      developer.log('   ✅ publisherNickname: $userNickname (MyApplication2格式)');
      developer.log('   ✅ replyContent: $replyContent');
      developer.log('   ✅ publisherAvatar: ${userAvatarUrl ?? "未提供"} (MyApplication2格式)');
      
      // 🔥 使用AES加密
      developer.log('🔐 开始AES加密回复数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(data);
      
      developer.log('🚀 准备发送加密请求到: /comments/replies');
      
      final startTime = DateTime.now();
      developer.log('⏰ 回复开始时间: ${startTime.toIso8601String()}');
      
      final response = await HttpService.to.post('/comments/replies', data: encryptedPayload);
      
      final endTime = DateTime.now();
      final duration = endTime.difference(startTime).inMilliseconds;
      developer.log('⏰ 回复结束时间: ${endTime.toIso8601String()}');
      developer.log('⏱️ 回复耗时: ${duration}ms');
      developer.log('📨 服务器响应: ${jsonEncode(response)}');
      
      final status = response['status'] ?? 'unknown';
      if (status == 'success') {
        developer.log('✅ 评论回复添加成功！');
      } else if (status == 'error') {
        final errorMsg = response['message'] ?? '未知错误';
        developer.log('❌ 评论回复添加失败: $errorMsg');
      }
      
      developer.log('🏁 =============== 评论回复完成 ===============');
      
      return response;
    } catch (e, stackTrace) {
      developer.log('💥 =============== 评论回复异常 ===============');
      developer.log('❌ 异常信息: $e');
      developer.log('📍 堆栈跟踪: $stackTrace');
      developer.log('🏁 =============== 异常处理结束 ===============');
      
      return {
        'status': 'error',
        'message': '添加回复失败: ${e.toString()}',
        'error_type': 'client_exception',
      };
    }
  }
}
